
    template<typename RefType>
    struct CFunction<RefType()>
    {
      virtual RefType operator()() = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0>
    struct CFunction<RefType(A0)>
    {
      virtual RefType operator()(A0) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1>
    struct CFunction<RefType(A0, A1)>
    {
      virtual RefType operator()(A0, A1) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2>
    struct CFunction<RefType(A0, A1, A2)>
    {
      virtual RefType operator()(A0, A1, A2) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2, typename A3>
    struct CFunction<RefType(A0, A1, A2, A3)>
    {
      virtual RefType operator()(A0, A1, A2, A3) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4>
    struct CFunction<RefType(A0, A1, A2, A3, A4)>
    {
      virtual RefType operator()(A0, A1, A2, A3, A4) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
    struct CFunction<RefType(A0, A1, A2, A3, A4, A5)>
    {
      virtual RefType operator()(A0, A1, A2, A3, A4, A5) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
    struct CFunction<RefType(A0, A1, A2, A3, A4, A5, A6)>
    {
      virtual RefType operator()(A0, A1, A2, A3, A4, A5, A6) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
    struct CFunction<RefType(A0, A1, A2, A3, A4, A5, A6, A7)>
    {
      virtual RefType operator()(A0, A1, A2, A3, A4, A5, A6, A7) = 0;
      virtual ~CFunction() { }
    };
  
    template<typename T, typename RefType>
    struct CFunctionFunctor<T, RefType()>
    : public CFunction<RefType()>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()()
      {
        return iT();
      }
    };
    
  
    template<typename T, typename RefType, typename A0>
    struct CFunctionFunctor<T, RefType(A0)>
    : public CFunction<RefType(A0)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0)
      {
        return iT(aA0);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1>
    struct CFunctionFunctor<T, RefType(A0, A1)>
    : public CFunction<RefType(A0, A1)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1)
      {
        return iT(aA0, aA1);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2>
    struct CFunctionFunctor<T, RefType(A0, A1, A2)>
    : public CFunction<RefType(A0, A1, A2)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2)
      {
        return iT(aA0, aA1, aA2);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2, typename A3>
    struct CFunctionFunctor<T, RefType(A0, A1, A2, A3)>
    : public CFunction<RefType(A0, A1, A2, A3)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2, A3 aA3)
      {
        return iT(aA0, aA1, aA2, aA3);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4>
    struct CFunctionFunctor<T, RefType(A0, A1, A2, A3, A4)>
    : public CFunction<RefType(A0, A1, A2, A3, A4)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2, A3 aA3, A4 aA4)
      {
        return iT(aA0, aA1, aA2, aA3, aA4);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
    struct CFunctionFunctor<T, RefType(A0, A1, A2, A3, A4, A5)>
    : public CFunction<RefType(A0, A1, A2, A3, A4, A5)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2, A3 aA3, A4 aA4, A5 aA5)
      {
        return iT(aA0, aA1, aA2, aA3, aA4, aA5);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
    struct CFunctionFunctor<T, RefType(A0, A1, A2, A3, A4, A5, A6)>
    : public CFunction<RefType(A0, A1, A2, A3, A4, A5, A6)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2, A3 aA3, A4 aA4, A5 aA5, A6 aA6)
      {
        return iT(aA0, aA1, aA2, aA3, aA4, aA5, aA6);
      }
    };
    
  
    template<typename T, typename RefType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
    struct CFunctionFunctor<T, RefType(A0, A1, A2, A3, A4, A5, A6, A7)>
    : public CFunction<RefType(A0, A1, A2, A3, A4, A5, A6, A7)>
    {
      T iT;
      CFunctionFunctor(const T& aT) : iT(aT) { }
      virtual RefType operator()(A0 aA0, A1 aA1, A2 aA2, A3 aA3, A4 aA4, A5 aA5, A6 aA6, A7 aA7)
      {
        return iT(aA0, aA1, aA2, aA3, aA4, aA5, aA6, aA7);
      }
    };
    
  
